RuleLabelledShape

      # File lib/geometry.rb, line 1623
1623:         def initialize(edges, points_and_materials, host_rule_id, host_rule_part)

1624:                 @shape_id = 1

1625:                 @group = Hash.new(nil)

1626:                 

1627:                 if Shade.using_sketchup

1628:                         @shape_transformation = Hash.new(Geom::Transformation.new)

1629:                         @layout_transformation = Geom::Transformation.new

1630:                         

1631:                         @observer = Hash.new(nil)

1632:                         

1633:                         @changed = true

1634:                         @badly_erased = false

1635:                         @partner_changed = false

1636:                         @avoid_bug = false

1637:                         

1638:                         @host_rule_id = host_rule_id

1639:                         @host_rule_part = host_rule_part

1640:                         

1641:                         @shape_id = shape_id

1642:                         

1643:                         @s = Hash.new(nil)

1644:                         Sketchup.active_model.layers.each { |layer|

1645:                                 @s[layer.name] = LinearLinkedList.new

1646:                         }

1647:                         @p = Hash.new(nil)

1648:                         Sketchup.active_model.layers.each { |layer|

1649:                                 @p[layer.name] = LinearLinkedList.new

1650:                         }

1651:                 else

1652:                         @shape_id = shape_id

1653:                 

1654:                         @s = Hash.new(nil)

1655:                         @s["Layer0"] = LinearLinkedList.new

1656:                         @p = Hash.new(nil)

1657:                         @p["Layer0"] = LinearLinkedList.new

1658:                 end

1659:                 

1660:                 super(edges, points_and_materials)

1661:                 

1662:         end

      # File lib/geometry.rb, line 2321
2321:         def ==(other_shape)

2322:                 result = true

2323:                 if (other_shape.kind_of? RuleLabelledShape)

2324:                         i = 0

2325:                         @s.keys.each{ |layer_name|

2326:                                 result = (result && ((@s[layer_name] == other_shape.s[layer_name])&&(@p[layer_name] == other_shape.p[layer_name])))

2327:                                 

2328:                                 i+=1

2329:                         }

2330:                 else

2331:                         result = false

2332:                 end

2333:                 return result

2334:         end

      # File lib/geometry.rb, line 2063
2063:         def add_label(point, value, layer_name)

2064:                 label = Label.new(value)

2065:                 point_list = LinearLinkedList.new

2066:                 

2067:                 node = LinearLinkedListNode.new(label, point_list, nil)

2068:                 

2069:                 inserted_node = @p[layer_name].insert_node(node) #Insert the node corresponding to the label of the point

2070:                 

2071:                 point_node = LinearLinkedListNode.new(OrderedPoint.new(point), nil, nil)

2072:                 inserted_node.list.insert_node(point_node) #Insert the point node

2073:         end

      # File lib/geometry.rb, line 2337
2337:         def clone()

2338:                 new_shape = RuleLabelledShape.new(Array.new,Array.new,nil,nil)

2339:                 @s.each_key { |layer_name|

2340:                         new_shape.s[layer_name] = @s[layer_name].clone

2341:                 }

2342:                 @p.each_key { |layer_name|

2343:                         new_shape.p[layer_name] = @p[layer_name].clone

2344:                 }

2345:                 return new_shape

2346:         end

      # File lib/geometry.rb, line 2168
2168:         def erase(print = false)

2169:                 if Shade.using_sketchup

2170:                         Shade.rule_groups_observer.observed_id_list.delete @shape_id

2171:                         Shade.project.modifying = true

2172:                         Shade.project.erasing = true

2173:                         @group.each_key {|layer_name|

2174:                         

2175:                                 if @group[layer_name] and !@group[layer_name].deleted?

2176:                                         @group[layer_name].entities.remove_observer @observer[layer_name]

2177:                                         @observer[layer_name] = nil

2178:                                         if @group[layer_name].valid? and !@avoid_bug #For avoiding bugs

2179:                                                 Sketchup.active_model.entities.erase_entities @group[layer_name]

2180:                                                 

2181:                                         end

2182:                                 end

2183:                                 Shade.project.modifying = true

2184:                         }

2185:                         Shade.project.modifying = false

2186:                         Shade.project.erasing = false

2187:                         @group = Hash.new(nil)

2188:                 end

2189:         end

      # File lib/geometry.rb, line 1761
1761:         def load(path)

1762: 

1763:                 if Shade.using_sketchup

1764:                         extension = ShadeUtils.get_extension(path)

1765: 

1766:                         if extension == "skp"

1767:                                 

1768:                                 #We remove everything

1769:                                 rules = Shade.project.execution.grammar.rules

1770:                                 rules.each {|rule|

1771:                                         rule.erase

1772:                                 }

1773:                                 Shade.project.execution.current_shape.erase

1774:                                 Sketchup.active_model.active_entities.erase_entities(Sketchup.active_model.active_entities.to_a) 

1775:                                 

1776:                                 path = path.tr("\\","/") 

1777:                                 Sketchup.active_model.save("trash.skp")

1778:                                 Sketchup.open_file(path) #A group is loaded

1779:                                 File.delete("trash.skp")

1780:                                 entities = Sketchup.active_model.entities[0].entities

1781:                                 

1782:                                 edges = Array.new

1783:                                 points_and_materials = Array.new

1784:                                 

1785:                                 entities.each { |e|

1786:                                         if e.kind_of? Sketchup::Edge

1787:                                                 edges.push e

1788:                                         elsif e.kind_of? Sketchup::Group

1789:                                                 e.entities.each { |ge| 

1790:                                                         if ge.kind_of? Sketchup::ConstructionPoint

1791:                                                                 points_and_materials.push [ge.position, e.material]

1792:                                                         end

1793:                                                 }

1794:                                                 

1795:                                         end

1796:                                 }

1797:                                 

1798:                                 @shape_transformation = @layout_transformation.inverse * Sketchup.active_model.entities[0].transformation

1799: 

1800:                                 self.refresh_from_info(edges, points_and_materials)

1801:                                 

1802:                                 Sketchup.active_model.active_entities.erase_entities(Sketchup.active_model.active_entities.to_a) 

1803:                                 

1804:                                 #We repaint everything

1805:                                 ShadeUtils.prepare_canvas(false)

1806:                                 rules.each {|rule|

1807:                                         rule.repaint

1808:                                 }

1809:                                 Shade.project.execution.current_shape.paint

1810:                         elsif extension == "txt"

1811:                                 layer_found = false

1812:                                 File.open(path, 'r') do |f|

1813:                                         while line = f.gets

1814:                                                 line_a1 = line.split(":")

1815:                                                 if line_a1[0].strip == "S" #Segment

1816:                                                         if !layer_found

1817:                                                                 if self.kind_of? CurrentLabelledShape

1818:                                                                         @s["Layer0"] = BalancedBinaryTree.new

1819:                                                                 else

1820:                                                                         @s["Layer0"] = LinearLinkedList.new

1821:                                                                 end

1822:                                                                 @p["Layer0"] = LinearLinkedList.new

1823:                                                                 layer_name = "Layer0"

1824:                                                                 layer_found = true

1825:                                                         end

1826:                                                         line_a = line_a1[1].split

1827:                                                         segment = Segment.new(OrderedPoint.new(Geom::Point3d.new(line_a[0].to_f.m, line_a[1].to_f.m, 0)), OrderedPoint.new(Geom::Point3d.new(line_a[2].to_f.m, line_a[3].to_f.m, 0)))

1828:                                                         segment_list = LinearLinkedList.new

1829: 

1830:                                                         if @s[layer_name].kind_of? LinearLinkedList

1831:                                                                 node = LinearLinkedListNode.new(segment.line_descriptor, segment_list, nil)

1832:                                                         else

1833:                                                                 node = BalancedBinaryTreeNode.new(Constants::BALANCED, nil, nil, segment.line_descriptor, segment_list)

1834:                                                         end

1835: 

1836:                                                         inserted_node = @s[layer_name].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

1837: 

1838:                                                         #We create an auxiliar list filled with the new segment to add, in order to make the union and obtain the maximal lines

1839:                                                         new_segment_list = LinearLinkedList.new

1840:                                                         segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

1841:                                                         new_segment_list.insert_node(segment_node)

1842: 

1843:                                                         op_rel(inserted_node.list,  new_segment_list, Constants::UNION, Constants::SEGMENTS)

1844: 

1845:                                                 elsif line_a1[0].strip == "L" #Label

1846:                                                         if !layer_found

1847:                                                                 if self.kind_of? CurrentLabelledShape

1848:                                                                         @s["Layer0"] = BalancedBinaryTree.new

1849:                                                                 else

1850:                                                                         @s["Layer0"] = LinearLinkedList.new

1851:                                                                 end

1852:                                                                 @p["Layer0"] = LinearLinkedList.new

1853:                                                                 layer_name = "Layer0"

1854:                                                                 layer_found = true

1855:                                                         end

1856:                                                         line_a = line_a1[1].split

1857:                                                         color = line_a[2]

1858:                                                         raise LoadError, "The color name: #{color} of shape in file #{path} is not recognized" unless Constants::RECOGNIZED_COLORS.include? color

1859:                                                         label = Label.new(line_a[2])

1860:                                                         point = OrderedPoint.new(Geom::Point3d.new(line_a[0].to_f.m, line_a[1].to_f.m, 0))

1861:                                                         point_list = LinearLinkedList.new

1862: 

1863:                                                         if @p[layer_name].kind_of? LinearLinkedList

1864:                                                                 node = LinearLinkedListNode.new(label, point_list, nil)

1865:                                                         else

1866:                                                                 node = BalancedBinaryTreeNode.new(Constants::BALANCED, nil, nil, label, point_list)

1867:                                                         end

1868: 

1869:                                                         inserted_node = @p[layer_name].insert_node(node) #Insert the node corresponding to the label of the point

1870: 

1871:                                                         point_node = LinearLinkedListNode.new(point, nil, nil)

1872:                                                         inserted_node.list.insert_node(point_node) #Insert the point node

1873:                                                 elsif line_a1[0].strip == "LAYER"

1874:                                                         layer_found = true

1875:                                                         layer_name = line_a1[1].strip

1876:                                                         if self.kind_of? CurrentLabelledShape

1877:                                                                 @s[layer_name] = BalancedBinaryTree.new

1878:                                                         else

1879:                                                                 @s[layer_name] = LinearLinkedList.new

1880:                                                         end

1881:                                                         @p[layer_name] = LinearLinkedList.new

1882:                                                 end

1883:                                         end

1884:                                 end

1885:                                 recompute_intersection_points

1886:                                 paint

1887:                         end

1888:                 else

1889:                         extension = ShadeUtils.get_extension(path)

1890: 

1891:                         if extension == "txt"

1892:                                 File.open(path, 'r') do |f|

1893:                                         layer_found = false

1894:                                         while line = f.gets

1895:                                                 line_a1 = line.split(":")

1896:                                                 if line_a1[0].strip == "S" #Segment

1897:                                                         if !layer_found

1898:                                                                 if self.kind_of? CurrentLabelledShape

1899:                                                                         @s["Layer0"] = BalancedBinaryTree.new

1900:                                                                 else

1901:                                                                         @s["Layer0"] = LinearLinkedList.new

1902:                                                                 end

1903:                                                                 @p["Layer0"] = LinearLinkedList.new

1904:                                                                 layer_name = "Layer0"

1905:                                                                 layer_found = true

1906:                                                         end

1907:                                                         line_a = line_a1[1].split

1908:                                                         segment = Segment.new(OrderedPoint.new(Point.new(line_a[0].to_f, line_a[1].to_f, 0)), OrderedPoint.new(Point.new(line_a[2].to_f, line_a[3].to_f, 0)))

1909:                                                         segment_list = LinearLinkedList.new

1910: 

1911:                                                         if @s[layer_name].kind_of? LinearLinkedList

1912:                                                                 node = LinearLinkedListNode.new(segment.line_descriptor, segment_list, nil)

1913:                                                         else

1914:                                                                 node = BalancedBinaryTreeNode.new(Constants::BALANCED, nil, nil, segment.line_descriptor, segment_list)

1915:                                                         end

1916: 

1917:                                                         inserted_node = @s[layer_name].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

1918: 

1919:                                                         #We create an auxiliar list filled with the new segment to add, in order to make the union and obtain the maximal lines

1920:                                                         new_segment_list = LinearLinkedList.new

1921:                                                         segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

1922:                                                         new_segment_list.insert_node(segment_node)

1923: 

1924:                                                         op_rel(inserted_node.list,  new_segment_list, Constants::UNION, Constants::SEGMENTS)

1925: 

1926:                                                 elsif line_a1[0].strip == "L" #Label

1927:                                                         if !layer_found

1928:                                                                 if self.kind_of? CurrentLabelledShape

1929:                                                                         @s["Layer0"] = BalancedBinaryTree.new

1930:                                                                 else

1931:                                                                         @s["Layer0"] = LinearLinkedList.new

1932:                                                                 end

1933:                                                                 @p["Layer0"] = LinearLinkedList.new

1934:                                                                 layer_name = "Layer0"

1935:                                                                 layer_found = true

1936:                                                         end

1937:                                                         line_a = line_a1[1].split

1938:                                                         color = line_a[2]

1939:                                                         raise LoadError, "The color name: #{color} of shape in file #{path} is not recognized" unless Constants::RECOGNIZED_COLORS.include? color

1940:                                                         label = Label.new(line_a[2])

1941:                                                         point = OrderedPoint.new(Point.new(line_a[0].to_f, line_a[1].to_f, 0))

1942:                                                         point_list = LinearLinkedList.new

1943: 

1944:                                                         if @p[layer_name].kind_of? LinearLinkedList

1945:                                                                 node = LinearLinkedListNode.new(label, point_list, nil)

1946:                                                         else

1947:                                                                 node = BalancedBinaryTreeNode.new(Constants::BALANCED, nil, nil, label, point_list)

1948:                                                         end

1949: 

1950:                                                         inserted_node = @p[layer_name].insert_node(node) #Insert the node corresponding to the label of the point

1951: 

1952:                                                         point_node = LinearLinkedListNode.new(point, nil, nil)

1953:                                                         inserted_node.list.insert_node(point_node) #Insert the point node

1954:                                                 elsif line_a1[0].strip == "LAYER"

1955:                                                         layer_found = true

1956:                                                         layer_name = line_a1[1].strip

1957:                                                         if self.kind_of? CurrentLabelledShape

1958:                                                                 @s[layer_name] = BalancedBinaryTree.new

1959:                                                         else

1960:                                                                 @s[layer_name] = LinearLinkedList.new

1961:                                                         end

1962:                                                         @p[layer_name] = LinearLinkedList.new

1963:                                                 end

1964:                                         end

1965:                                 end

1966:                                 recompute_intersection_points

1967:                                 paint

1968:                         end

1969:                 end

1970: 

1971:                 

1972:         end

      # File lib/geometry.rb, line 2195
2195:         def paint(layer = nil)

2196:                 if Shade.using_sketchup       

2197:                         Shade.project.modifying = true

2198:                         entities = Sketchup.active_model.entities

2199:                         

2200:                         if !layer

2201:                                 erase

2202:                                 Shade.project.modifying = true

2203:                                 @s.each_key { |layer_name|

2204:                                 

2205:                                         if ((@s[layer_name].size > 0) or (@p[layer_name].size > 0))

2206:                                 

2207:                                                 @group[layer_name] = entities.add_group

2208:                                                 

2209:                                                 

2210:                                                 @s[layer_name].reset_iterator

2211:                                                 while (node = @s[layer_name].get_next)

2212:                                                         node.list.reset_iterator

2213:                                                         while (segment_node = node.list.get_next)

2214:                                                                 @group[layer_name].entities.add_edges segment_node.key.tail.point, segment_node.key.head.point

2215:                                                         end

2216:                                                 end

2217:                                                 

2218:                                                 @p[layer_name].reset_iterator

2219:                                                 while (node = @p[layer_name].get_next)

2220:                                                         label = node.key

2221:                                                         node.list.reset_iterator

2222:                                                         while (labelled_point_node = node.list.get_next) 

2223:                                                                 if !(label.value==Constants::INTERSECTION_LABEL) #The label is a coloured circle

2224:                                                                         label_group = @group[layer_name].entities.add_group

2225:                                                                         

2226:                                                                         # Add circle

2227:                                                                         edges = label_group.entities.add_circle labelled_point_node.key.point, Constants::LABEL_VECTOR, Shade.label_radius

2228:                                                                         #Add construction point in order to locate the center later

2229:                                                                         label_group.entities.add_cpoint labelled_point_node.key.point

2230:                                                                         #Add face

2231:                                                                         face = label_group.entities.add_face edges     

2232:                                                                         

2233:                                                                         #Give color to the face

2234:                                                                         label_group.material = label.value

2235:                                                                 end

2236:                                                         end

2237:                                                 end

2238:                                                 

2239:                                                 #Find or create the layer

2240:                                                 found = false

2241:                                                 layer = nil

2242:                                                 i = 0

2243:                                                 while (!found and (i < Sketchup.active_model.layers.length))

2244:                                                         if (Sketchup.active_model.layers[i].name == layer_name)

2245:                                                                 found = true

2246:                                                                 layer = Sketchup.active_model.layers[i]

2247:                                                         end

2248:                                                         i+=1

2249:                                                 end

2250:                                                 if !found

2251:                                                         layer = Sketchup.active_model.layers.add(layer_name)

2252:                                                         # Draw vertical line

2253:                                                         point1 = Constants::PTS_V[0].clone

2254:                                                         point2 = Constants::PTS_V[1].clone

2255:                                                         v_group = Sketchup.active_model.entities.add_group

2256:                                                         v_group.entities.add_line point1,point2

2257:                                                         v_group.layer = layer

2258:                                                 end

2259:                                                 

2260:                                                 @group[layer_name].layer = layer

2261:                                                 

2262:                                                 @group[layer_name].transformation = @layout_transformation

2263:                                                 

2264:                                                 @observer[layer_name] = RuleShapeObserver.new(self)

2265:                                                 @group[layer_name].entities.add_observer @observer[layer_name]

2266:                                                 @shape_id = @group[layer_name].entityID

2267:                                                 Shade.rule_groups_observer.observed_id_list.push @group[layer_name].entityID

2268:                                         end

2269:                                 }

2270:                         else

2271:                                 if ((@s[layer.name].size > 0) or (@p[layer.name].size > 0))

2272:                                         @group[layer.name] = entities.add_group

2273:                                                 

2274:                                                 

2275:                                         @s[layer.name].reset_iterator

2276:                                         while (node = @s[layer.name].get_next)

2277:                                                 node.list.reset_iterator

2278:                                                 while (segment_node = node.list.get_next)

2279:                                                         @group[layer.name].entities.add_edges segment_node.key.tail.point, segment_node.key.head.point

2280:                                                 end

2281:                                         end

2282:                                         

2283:                                         @p[layer.name].reset_iterator

2284:                                         while (node = @p[layer.name].get_next)

2285:                                                 label = node.key

2286:                                                 node.list.reset_iterator

2287:                                                 while (labelled_point_node = node.list.get_next)  

2288:                                                         if !(label.value==Constants::INTERSECTION_LABEL) #The label is a coloured circle

2289:                                                                 label_group = @group[layer.name].entities.add_group

2290:                                                                 

2291:                                                                 # Add circle

2292:                                                                 edges = label_group.entities.add_circle labelled_point_node.key.point, Constants::LABEL_VECTOR, Shade.label_radius

2293:                                                                 #Add construction point in order to locate the center later

2294:                                                                 label_group.entities.add_cpoint labelled_point_node.key.point

2295:                                                                 #Add face

2296:                                                                 face = label_group.entities.add_face edges      

2297:                                                                 

2298:                                                                 #Give color to the face

2299:                                                                 label_group.material = label.value

2300:                                                         end

2301:                                                 end

2302:                                         end

2303:                                         

2304:                                         @group[layer.name].layer = layer

2305:                                         

2306:                                         @group[layer.name].transformation = @layout_transformation

2307:                                         

2308:                                         @observer[layer.name] = RuleShapeObserver.new(self)

2309:                                         @group[layer.name].entities.add_observer @observer[layer.name]

2310:                                         @shape_id = @group[layer.name].entityID

2311:                                         Shade.rule_groups_observer.observed_id_list.push @group[layer.name].entityID       

2312:                                 end

2313:                         end

2314:                         Shade.project.modifying = false

2315:                 end

2316:         end

      # File lib/geometry.rb, line 2078
2078:         def refresh(force = false)

2079:                 if Shade.using_sketchup

2080:                         Shade.project.modifying = true

2081:                         if @changed or @badly_erased or force

2082:                                 @avoid_bug = (@avoid_bug or @badly_erased)

2083:                                 @changed = false

2084:                                 @badly_erased = false

2085:                                 paint()             

2086:                                 @avoid_bug = false

2087:                         end

2088:                         Shade.project.modifying = false

2089:                 end

2090:         end

      # File lib/geometry.rb, line 2097
2097:         def refresh_from_entities(entities, transformation, layer_name)

2098:                 if Shade.using_sketchup

2099:                         

2100:                         edges = Array.new

2101:                         points_and_materials = Array.new

2102:                         

2103:                         final_transformation = transformation.inverse * @shape_transformation[layer_name]

2104:                         

2105:                         entities.each { |e|

2106:                                 if e.kind_of? Sketchup::Edge

2107:                                         edges.push e

2108:                                 elsif e.kind_of? Sketchup::Group

2109:                                         e.entities.each { |ge| 

2110:                                                 if ge.kind_of? Sketchup::ConstructionPoint

2111:                                                         #points_and_materials.push [final_transformation * ge.position, e.material]

2112:                                                         #I don't understand why it is not necessary to apply the transformation to the construction points

2113:                                                         #Maybe their position is not given w.r.t. their parent groups...

2114:                                                         t =  @layout_transformation.inverse * e.transformation

2115:                                                         points_and_materials.push [t * ge.position, e.material]

2116:                                                 end

2117:                                         }

2118:                                         

2119:                                 end

2120:                         }

2121:                         

2122:                         @s[layer_name] = LinearLinkedList.new

2123:                         @p[layer_name] = LinearLinkedList.new

2124:                         edges.each { |e|

2125:                                 segment = Segment.new(OrderedPoint.new(final_transformation*e.start.position), OrderedPoint.new(final_transformation*e.end.position))

2126:                                 segment_list = LinearLinkedList.new

2127: 

2128:                                 if @s[layer_name].kind_of? LinearLinkedList

2129:                                         node = LinearLinkedListNode.new(segment.line_descriptor, segment_list, nil)

2130:                                 else

2131:                                         node = BalancedBinaryTreeNode.new(Constants::BALANCED, nil, nil, segment.line_descriptor, segment_list)

2132:                                 end

2133:                                 

2134:                                 inserted_node = @s[layer_name].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

2135: 

2136:                                 #We create an auxiliar list filled with the new segment to add, in order to make the union and obtain the maximal lines

2137:                                 new_segment_list = LinearLinkedList.new

2138:                                 segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

2139:                                 new_segment_list.insert_node(segment_node)

2140:                                 

2141:                                 op_rel(inserted_node.list,  new_segment_list, Constants::UNION, Constants::SEGMENTS)

2142:                         }

2143:                         

2144:                         #Compound the label lists

2145:                         points_and_materials.each { |pair|

2146:                                 point = pair[0]

2147:               

2148:                                 label = Label.new(pair[1])

2149:                                 

2150:                                 point_list = LinearLinkedList.new

2151:                                 

2152:                                 if @p[layer_name].kind_of? LinearLinkedList

2153:                                         node = LinearLinkedListNode.new(label, point_list, nil)

2154:                                 else

2155:                                         node = BalancedBinaryTreeNode.new(Constants::BALANCED, nil, nil, label, point_list)

2156:                                 end

2157:                                 inserted_node = @p[layer_name].insert_node(node) #Insert the node corresponding to the label of the point

2158:                                 

2159:                                 point_node = LinearLinkedListNode.new(OrderedPoint.new(point), nil, nil)

2160:                                 inserted_node.list.insert_node(point_node) #Insert the point node

2161:                         }            

2162:             

2163:                         recompute_intersection_points

2164:                 end

2165:         end

      # File lib/geometry.rb, line 1667
1667:         def save(path)

1668:                 if Shade.using_sketchup

1669:                         extension = ShadeUtils.get_extension(path)

1670: 

1671:                         if extension == "skp"

1672:                                 rules = Shade.project.execution.grammar.rules

1673:                                 rules.each {|rule|

1674:                                         rule.erase

1675:                                 }

1676:                                 Sketchup.active_model.entities

1677:                                 Shade.project.execution.current_shape.erase

1678:                                 

1679:                                 Sketchup.active_model.active_entities.erase_entities(Sketchup.active_model.active_entities.to_a) 

1680:                                 

1681:                                 layout_t = @layout_transformation

1682:                                 @layout_transformation = Geom::Transformation.new

1683:                                 self.paint

1684:                                 @layout_transformation = layout_t

1685:                                 

1686:                                 path = path.tr("\\","/") 

1687:                                 Sketchup.active_model.save(path)

1688:                                 

1689:                                 ShadeUtils.prepare_canvas(false)

1690:                                 rules.each {|rule|

1691:                                         rule.repaint

1692:                                 }

1693:                                 Shade.project.execution.current_shape.paint

1694:                         elsif extension == "txt"

1695:                                 File.open(path, 'w') do |f|

1696:                                         Sketchup.active_model.layers.each {|layer|

1697:                                                 f.write("LAYER: #{layer.name}\n")

1698:                                                 if @s[layer.name]

1699:                                                         @s[layer.name].reset_iterator

1700:                                                         while s_node = @s[layer.name].get_next

1701:                                                                 s_node.list.reset_iterator

1702:                                                                 while s = s_node.list.get_next

1703:                                                                 tail_x = ((s.key.tail.x.to_f.to_m * 100).round.to_f / 100)

1704:                                                                 tail_y = ((s.key.tail.y.to_f.to_m * 100).round.to_f / 100)

1705:                                                                 head_x = ((s.key.head.x.to_f.to_m* 100).round.to_f / 100)

1706:                                                                 head_y = ((s.key.head.y.to_f.to_m * 100).round.to_f / 100)

1707:                                                                         f.write("S: #{tail_x} #{tail_y} #{head_x} #{head_y}\n")

1708:                                                                 end

1709:                                                         end

1710:                                                 end

1711:                                                 if @p[layer.name]

1712:                                                         @p[layer.name].reset_iterator

1713:                                                         while l_node = @p[layer.name].get_next

1714:                                                                 if !(l_node.key.value == Constants::INTERSECTION_LABEL)

1715:                                                                         l_node.list.reset_iterator

1716:                                                                         while l = l_node.list.get_next

1717:                                                                                 key_x = ((l.key.x.to_f.to_m * 100).round.to_f / 100)

1718:                                                                                 key_y = ((l.key.y.to_f.to_m * 100).round.to_f / 100)

1719:                                                                                 f.write("L: #{key_x} #{key_y} #{l_node.key.value}\n")

1720:                                                                         end

1721:                                                                 end

1722:                                                         end

1723:                                                 end

1724:                                         }

1725:                                 end

1726:                         end

1727:                 else

1728:                         extension = ShadeUtils.get_extension(path)

1729: 

1730:                         if extension == "txt"

1731:                                 File.open(path, 'w') do |f|

1732:                                         @s.each_key { |layer_name|

1733:                                                 f.write("LAYER: #{layer_name}\n")

1734:                                                 @s[layer_name].reset_iterator

1735:                                                 while s_node = @s[layer_name].get_next

1736:                                                         s_node.list.reset_iterator

1737:                                                         while s = s_node.list.get_next

1738:                                                                 f.write("S: #{s.key.tail.x.to_f} #{s.key.tail.y.to_f} #{s.key.head.x.to_f} #{s.key.head.y.to_f}\n")

1739:                                                         end

1740:                                                 end

1741:                                                 @p[layer_name].reset_iterator

1742:                                                 while l_node = @p[layer_name].get_next

1743:                                                         if !(l_node.key.value == Constants::INTERSECTION_LABEL)

1744:                                                                 l_node.list.reset_iterator

1745:                                                                 while l = l_node.list.get_next

1746:                                                                         f.write("L: #{l.key.x.to_f} #{l.key.y.to_f} #{l_node.key.value}\n")

1747:                                                                 end

1748:                                                         end

1749:                                                 end

1750:                                         }

1751:                                 end

1752:                         end

1753:                 end

1754: 

1755:                 

1756:         end

      # File lib/geometry.rb, line 1977
1977:         def transform(t)

1978:                 #Extract the coefficients of the transformation matrix

1979:                 ax = t[0]

1980:                 bx = t[1]

1981:                 cx = t[2]

1982:                 ay = t[3]

1983:                 by = t[4]

1984:                 cy = t[5]

1985:                 new_shape = self.clone

1986:                 @s.each_key {|layer_name|

1987:                         #First, we transform the segments

1988:                         new_s = LinearLinkedList.new

1989:                         new_shape.s[layer_name].reset_iterator

1990:                         #Second, we remove the intersection points, if any

1991:                         new_shape.p[layer_name].delete_node(Label.new(Constants::INTERSECTION_LABEL))

1992:                         while (node = new_shape.s[layer_name].get_next)

1993:                                 new_line_descriptor = nil

1994:                                 

1995:                                 segment_list = node.list

1996:                                 segment_list.reset_iterator

1997:                                 

1998:                                 new_segment_list = LinearLinkedList.new

1999:                                 while (segment_node = segment_list.get_next)

2000:                                         tail = segment_node.key.tail

2001:                                         head = segment_node.key.head

2002:                                         #Transform the tail

2003:                                         new_tail_x = tail.x * ax + tail.y * bx + cx

2004:                                         new_tail_y = tail.x * ay + tail.y * by + cy

2005:                                         new_tail = Point.new(new_tail_x, new_tail_y, 0)

2006:                                         #Transform the head

2007:                                         new_head_x = head.x * ax + head.y * bx + cx

2008:                                         new_head_y = head.x * ay + head.y * by + cy

2009:                                         new_head = Point.new(new_head_x, new_head_y, 0)

2010:                                         

2011:                                         new_segment = Segment.new(OrderedPoint.new(new_tail), OrderedPoint.new(new_head))

2012:                                         new_segment_list.insert_node(LinearLinkedListNode.new(new_segment, nil, nil))

2013:                                         if !new_line_descriptor

2014:                                                 new_line_descriptor = new_segment.line_descriptor

2015:                                         end

2016:                                 end

2017:                                 new_node = LinearLinkedListNode.new(new_line_descriptor, new_segment_list, nil)

2018:                                 new_s.insert_node(new_node)

2019:                         end

2020:                         new_shape.s[layer_name] = new_s

2021:                         

2022:                         #Second, we transform the points

2023:                         new_p = LinearLinkedList.new

2024:                         new_shape.p[layer_name].reset_iterator

2025:                         while (node = new_shape.p[layer_name].get_next)

2026:                                 new_label = node.key

2027:                                 

2028:                                 point_list = node.list

2029:                                 point_list.reset_iterator

2030:                                 

2031:                                 new_point_list = LinearLinkedList.new

2032:                                 while (point_node = point_list.get_next)

2033:                                         point = point_node.key.point

2034:                                         #Transform the point

2035:                                         new_point_x = point.x * ax + point.y * bx + cx

2036:                                         new_point_y = point.x * ay + point.y * by + cy

2037:                                         new_point = Point.new(new_point_x, new_point_y, 0)

2038:                                         

2039:                                         new_point_list.insert_node(LinearLinkedListNode.new(OrderedPoint.new(new_point), nil, nil))

2040:                                 end

2041:                                 new_node = LinearLinkedListNode.new(new_label, new_point_list, nil)

2042:                                 new_p.insert_node(new_node)

2043:                         end

2044:                         new_shape.p[layer_name] = new_p

2045:                 }

2046:                 

2047:                 new_shape.recompute_intersection_points

2048:                 

2049:                 return new_shape

2050:         end

      # File lib/geometry.rb, line 2055
2055:         def transformation(layer_name)

2056:                 return @layout_transformation * @shape_transformation[layer_name]

2057:         end